FXLOG

// winit's Wayland implementation
pub fn set_visible(&self, _visible: bool) {
    // Not possible on Wayland.
}

// gdk/wayland/gdkwindow-wayland.c
static void gdk_wayland_window_hide(GdkWindow *window) {
    GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND(window->impl);
    
    wl_surface_attach(impl->display_server.wl_surface, NULL, 0, 0);
    wl_surface_commit(impl->display_server.wl_surface);
    _gdk_window_clear_update_area(window);
}

// WaylandToplevelWindow::Hide()
void WaylandToplevelWindow::Hide() {
    shell_toplevel_.reset();  // Destroy xdg_toplevel
    connection()->buffer_manager_host()->ResetSurfaceContents(root_surface());
}

// WaylandToplevelWindow::Show()
void WaylandToplevelWindow::Show(bool inactive) {
    if (!CreateShellToplevel()) { ... }  // Recreate xdg_toplevel
}

┌────────────────────────────┐
│                    Rustle (Application Layer)                     │
├────────────────────────────┤
│                    iced (GUI Framework)                     │
├────────────────────────────┤  
│                 iced_winit (Window Management)                  │
├────────────────────────────┤
│                    winit (Window Abstraction)                    │
├────────────────────────────┤  
│         smithay-client-toolkit (Wayland Wrapper)          │
├────────────────────────────┤
│              wayland-client (Protocol Bindings)                 │
├────────────────────────────┤
│                  Wayland Compositor                    │
└────────────────────────────┘

pub fn set_visible(&self, visible: bool) {
    // According to the XDG Shell protocol:
    // - "Attaching a null buffer to a toplevel unmaps the surface."
    // - "The client can re-map the toplevel by performing a commit without any
    //    buffer attached, waiting for a configure event and handling it as usual."

    let surface = self.window.wl_surface();

    if visible {
        {
            let mut state = self.window_state.lock().unwrap();
            state.set_visible(true);
            // Reset frame callback state to break deadlock
            state.frame_callback_reset();
        }

        surface.commit();
        self.request_redraw();
    } else {
        self.window_state.lock().unwrap().set_visible(false);
        
        // Clear pending redraw requests
        self.window_requests.redraw_requested.store(false, Ordering::Relaxed);

        // Unmap according to protocol: attach(NULL) + commit
        surface.attach(None, 0, 0);
        surface.commit();
    }
}

pub enum Action {
    // ...existing actions...
    
    /// Set the visibility of the window.
    SetVisible(Id, bool),
}

/// Sets the visibility of the window.
pub fn set_visible<T>(id: Id, visible: bool) -> Task<T> {
    task::effect(crate::Action::Window(Action::SetVisible(id, visible)))
}

window::Action::SetVisible(id, visible) => {
    if let Some(window) = window_manager.get_mut(id) {
        window.raw.set_visible(visible);
    }
}

// Hyprland crash stack
CWindow::create(CXDGSurfaceResource)
CWLSurface::assign
CWLSurface::init  // Crash point

┌───────────────────────────┐
│  wgpu waits for frame callback to submit buffer            │
│                        ↓                            │
│  compositor waits for buffer to send frame callback      │
│                        ↓                            │
│                       Deadlock!                         │
└───────────────────────────┘

state.frame_callback_reset();  // Reset to None, allowing immediate redraw

// 1. Check visible in refresh_frame()
pub fn refresh_frame(&mut self) -> bool {
    if !self.visible {
        return false;  // Do not refresh decorations when hidden
    }
    // ...
}

// 2. Check visible in request_redraw()
pub fn request_redraw(&self) {
    if !self.window_state.lock().unwrap().visible() {
        return;  // Do not request redraw when hidden
    }
    // ...
}

// 3. Clear pending redraw when set_visible(false)
self.window_requests.redraw_requested.store(false, Ordering::Relaxed);

// 4. Check visible when dispatching in event loop
if !window.visible() {
    window_requests.get(window_id).unwrap().take_redraw_requested();
    return None;  // Do not dispatch RedrawRequested
}

Hiding the window:
┌────────────────────────┐
│ 1. set_visible(false)                          │
│ 2. Set visible state to false                   │
│ 3. Clear pending redraw requests                    │
│ 4. wl_surface.attach(NULL, 0, 0)               │
│ 5. wl_surface.commit()                         │
│ → Surface is unmaped, compositor no longer displays it     │
└────────────────────────┘

Showing the window:
┌────────────────────────┐
│ 1. set_visible(true)                           │
│ 2. Set visible state to true                    │
│ 3. Reset frame_callback_state (break deadlock)        │
│ 4. wl_surface.commit()                         │
│ 5. request_redraw()                            │
│ → Triggers redraw, wgpu attaches buffer, window reappears  │
└────────────────────────┘

// In iced application
Message::ToggleWindow => {
    self.window_hidden = !self.window_hidden;
    let visible = !self.window_hidden;
    
    return iced::window::latest().and_then(move |id| {
        iced::window::set_visible(id, visible)
    });
}